//导入路由
const router = require('express').Router()
// 导入用户类
const Transaction = require('../models/transactionModel')
// 导入jwt模块 （jsonwebtoken）
const Jwt = require('../common/token/jwt')
//导入aes加密模块
const aes = require('../common/aes/index')
// 创建用户类的实例
const transactionModel = new Transaction()


// 添加记账信息
// 地址：/api/transaction/add
// 方式：POST
// 参数：token,amount, category, description, transaction_date, transaction_type
// 响应数据格式：json格式
// 示例： http://localhost:4000/api/transaction/add
router.post('/add', async (req, res) => {
    let token = req.body.token || req.headers.token;
    let { amount, category, description, transaction_type } = req.body;
    console.log(req.body);

    if (token) {
        let result = new Jwt(token).verifyToken();
        if (result.code == 200) {
            // 获取用户id
            let user_id = result.info.data;
            // 获取当前的日期和时间 
            let date = new Date();
            let transaction_date = date.toISOString().slice(0, 19).replace('T', ' ');
            console.log(transaction_date);
            console.log(user_id);

            // 调用交易模型添加方法
            try {
                const content = await transactionModel.add(user_id, amount, category, description, transaction_date, transaction_type);
                console.log(content);

                res.send(content); // 返回添加结果
            } catch (err) {
                res.send(err); // 发送异常
            }
        } else {
            res.send({
                code: -1,
                msg: "登录已经失效了，请重新登录"
            });
        }
    } else {
        res.send({
            code: -1,
            msg: "缺少参数"
        });
    }
});

// 获取本月收支数据
// 地址：/api/transaction/getMonthlyFinancials
// 方式：POST
// 参数：token
// 响应数据格式：json格式
// 示例： http://localhost:4000/api/transaction/getMonthlyFinancials
router.post('/getMonthlyFinancials', async (req, res) => {
    let token = req.body.token || req.headers.token;

    if (token) {
        let result = new Jwt(token).verifyToken();
        if (result.code == 200) {
            // 获取用户id
            let user_id = result.info.data;
            console.log(user_id);

            // 获取当前日期
            const currentDate = new Date();
            console.log(currentDate);

            // 获取当前年份和月份
            const year = currentDate.getFullYear();
            const month = currentDate.getMonth(); // 0-11
            console.log(year, month);

            // 获取本月第一天（1号）
            const startOfMonth = new Date(year, month, 1).toISOString().slice(0, 19).replace('T', ' ');
            console.log(startOfMonth);

            // 获取下个月第一天（用来计算本月最后一天）
            const nextMonth = month + 1;
            const endOfMonth = new Date(year, nextMonth, 0).toISOString().slice(0, 19).replace('T', ' ');
            console.log(endOfMonth);

            try {
                // 获取本月支出
                const totalExpenses = await transactionModel.getMonthlyExpenses(user_id, startOfMonth, endOfMonth);
                console.log(`本月支出: ${totalExpenses}`);

                // 获取本月收入
                const totalIncome = await transactionModel.getMonthlyIncome(user_id, startOfMonth, endOfMonth);
                console.log(`本月收入: ${totalIncome}`);

                // 确保金额都保留两位小数
                const formattedTotalExpenses = parseFloat(totalExpenses).toFixed(2);
                const formattedTotalIncome = parseFloat(totalIncome).toFixed(2);

                // 计算结余
                const balance = (parseFloat(formattedTotalIncome) - parseFloat(formattedTotalExpenses)).toFixed(2);

                // 将支出、收入和结余整合为数组
                const financialData = [
                    {
                        totalExpenses: formattedTotalExpenses,
                        totalIncome: formattedTotalIncome,
                        balance: balance
                    }
                ];

                res.send({
                    code: 200,
                    msg: "获取本月财务数据成功",
                    result: financialData
                });
            } catch (err) {
                res.send(err); // 发送异常
            }
        } else {
            res.send({
                code: -1,
                msg: "登录已经失效了，请重新登录"
            });
        }
    } else {
        res.send({
            code: -1,
            msg: "缺少参数"
        });
    }
});



// 获取近3日账单信息
// 地址：/api/transaction/getRecentBills
// 方式：POST
// 参数：token
// 响应数据格式：json格式
// 示例： http://localhost:4000/api/transaction/getRecentBills
router.post('/getRecentBills', async (req, res) => {
    let token = req.body.token || req.headers.token;

    if (token) {
        let result = new Jwt(token).verifyToken();
        if (result.code == 200) {
            // 获取用户id
            let user_id = result.info.data;

            // 获取当前日期，并计算出近3日的开始和结束时间
            const today = new Date();
            const threeDaysAgo = new Date();
            threeDaysAgo.setDate(today.getDate() - 3);

            // 格式化替代的日期格式为 'YYYY-MM-DD'
            const startDate = threeDaysAgo.toISOString().slice(0, 10);
            const endDate = today.toISOString().slice(0, 10);

            try {
                const recentBills = await transactionModel.getRecentBills(user_id, startDate, endDate);

                // 遍历账单，确保金额字段保留两位小数
                const formattedBills = recentBills.map(bill => {
                    return {
                        ...bill,
                        amount: parseFloat(bill.amount).toFixed(2) // 假设金额字段是 amount
                    };
                });

                res.send({
                    code: 200,
                    msg: "获取近3日账单信息成功",
                    result: formattedBills
                });
            } catch (err) {
                res.send(err); // 发送异常
            }
        } else {
            res.send({
                code: -1,
                msg: "登录已经失效了，请重新登录"
            });
        }
    } else {
        res.send({
            code: -1,
            msg: "缺少参数"
        });
    }
});


// 获取用户财务信息（总资产、总负债、净资产）
// 地址： /api/transaction/financialStatus
// 方式： GET
// 参数： token
// 响应数据格式：json格式
// 示例： http://localhost:4000/api/transaction/financialStatus
// 获取用户财务信息（总资产、总负债、净资产）
router.get('/financialStatus', async (req, res) => {
    let token = req.headers.token || req.query.token;

    if (token) {
        let result = new Jwt(token).verifyToken();
        if (result.code === 200) {
            const user_id = result.info.data; // 从 token 中获取用户 ID

            try {
                const totalAssets = await transactionModel.getTotalAssets(user_id);
                const totalExpenditures = await transactionModel.getTotalExpenditures(user_id);
                const totalLiabilities = await transactionModel.getTotalLiabilities(user_id);

                // 确保金额保留两位小数
                const formattedTotalAssets = parseFloat(totalAssets).toFixed(2);
                const formattedTotalExpenditures = parseFloat(totalExpenditures).toFixed(2);
                const formattedTotalLiabilities = parseFloat(totalLiabilities).toFixed(2);

                const netAssets = (parseFloat(formattedTotalAssets) - parseFloat(formattedTotalExpenditures)).toFixed(2); // 净资产计算

                res.send({
                    code: 200,
                    msg: "获取财务状态成功",
                    result: {
                        total_assets: formattedTotalAssets,
                        total_expenditures: formattedTotalExpenditures, // 如果需要支出信息可以取消注释
                        total_liabilities: formattedTotalLiabilities,
                        net_assets: netAssets
                    }
                });
            } catch (err) {
                res.send(err); // 发送异常
            }
        } else {
            res.send({
                code: -1,
                msg: "登录已经失效了，请重新登录"
            });
        }
    } else {
        res.send({
            code: -1,
            msg: "缺少参数"
        });
    }
});


// 获取所有账单信息并按日期分组
// 地址： /api/transaction/billsByDate
// 请求方式： GET
// 参数：token
// 响应数据格式：json格式
// 示例：http://localhost:4000/api/transaction/billsByDate
router.get('/billsByDate', async (req, res) => {
    let token = req.headers.token || req.query.token;

    if (token) {
        let result = new Jwt(token).verifyToken();
        if (result.code === 200) {
            const user_id = result.info.data; // 从 token 中获取用户 ID

            try {
                const bills = await transactionModel.getBillsByUserId(user_id); // 获取账单信息
                const groupedBills = transactionModel.groupBillsByDate(bills); // 按日期分组

                // 反转结果数组以确保倒序
                const reversedResult = groupedBills.reverse();

                res.send({
                    code: 200,
                    msg: "获取账单信息成功",
                    result: reversedResult
                });
            } catch (err) {
                res.send(err); // 发送异常
            }
        } else {
            res.send({
                code: -1,
                msg: "登录已经失效了，请重新登录"
            });
        }
    } else {
        res.send({
            code: -1,
            msg: "缺少参数"
        });
    }
});


// 获取所有类别的支出总和
// 地址： /api/transaction/getTotalExpensesByCategory
// 请求方式： POST
// 参数：token
// 响应数据格式：json格式
// 示例：http://localhost:4000/api/transaction/getTotalExpensesByCategory
router.post('/getTotalExpensesByCategory', async (req, res) => {
    let token = req.body.token || req.headers.token;

    if (token) {
        let result = new Jwt(token).verifyToken();
        if (result.code === 200) {
            // 获取用户id
            let user_id = result.info.data;

            try {
                const totalExpenses = await transactionModel.getExpensesByCategory(user_id);

                res.send({
                    code: 200,
                    msg: "获取各类别支出总和成功",
                    result: totalExpenses
                });
            } catch (err) {
                res.send(err); // 发送异常
            }
        } else {
            res.send({
                code: -1,
                msg: "登录已经失效了，请重新登录"
            });
        }
    } else {
        res.send({
            code: -1,
            msg: "缺少参数"
        });
    }
});









//挂载路由
module.exports = router